package com.foundersoftware.commons.organization;

import java.io.Serializable;

import com.foundersoftware.commons.organization.model.BusinessLeader;
import com.foundersoftware.commons.organization.model.Employee;
import com.foundersoftware.commons.organization.model.OrganizationUnit;
import com.foundersoftware.commons.organization.model.OrganizationUnitType;
import com.foundersoftware.commons.organization.model.Position;
import com.foundersoftware.commons.organization.model.PositionType;
import com.foundersoftware.commons.organization.model.Responsibility;
import com.foundersoftware.commons.organization.model.Role;
import com.foundersoftware.commons.organization.model.RoleType;
import com.foundersoftware.commons.organization.model.WorkGroup;
import com.foundersoftware.commons.organization.model.WorkGroupType;

/**
 *<p>
 *组织管理器接口(OrganizationManager)是精伦组织机构的主要接口,实际上它是一个Facade，也是一个服务类。
 * 客户端一般都是与这个接口交互。
 *</p>
 * <p>
 * 客户端不要试图直接创建它的实例,即不要像如下的示例代码那样使用：
 *  <pre>
 *    OrganizationManager orgMgr = new ...// 不要这样使用
 *  </pre>
 * 正确创建<code>OrganizationManager</code>实例的方式是使用<code>
 * {@link com.routon.software.organization.OrganizationManagerFactory}</code>产生:
 *  <pre>
 *     OrganizationManager orgMgr = OrganizationManagerFactory.createVolatileOrganizationManager();//根据需要可以调用不同的方法来创建
 *  </pre>
 * 进一步的信息可以参看<code>{@link OrganizationManagerFactory}</code>的示例。
 * </p>
 *
 * <br>这个接口内方法命名遵循一定的约定，即命名设计模式：
 * <li>createXX:表示创建XX
 * <li>modifyXX：表示修改XX
 * <li>deleteXX：表示删除XX
 * <li>getXX：表示获取XX
 * <li>getAllXX:获取所有的XX
 *
 * <br>注:XX可以是,Employee,OrganizationUnit,OrganizationUnitType,OrganizationUnit,Position,RoleType,Role,WorkGroupType,WorkGroup中任一个。
 *
 *
 *
 *
 * @see Employee
 * @see OrganizationUnit
 * @see OrganizationUnitType
 * @see OrganizationUnit
 * @see PositionType
 * @see Position
 * @see RoleType
 * @see Role
 * @see WorkGroupType
 * @see WorkGroup
 * @author <href mailto:wuhongjun@routon.com>(吴红军)
 * @version 3.0
 */
public interface OrganizationManager extends Serializable {

    //------------------------------新建类接口-----------------------------------
    /**
     * 用<code>Employee</code>创建一个雇员。
     * @param employee 将要创建的雇员信息
     * @throws IllegalArgumentException 假如参数employee为null。
     * @throws ObjectAlreadyExistsException 假如要创建的雇员已经存在。
     * @throws OrganizationException  包装了一个底层异常，比如底层数据源的异常，JNDI查找异常等等。
     */
    Employee createEmployee(Employee employee) throws
            ObjectAlreadyExistsException, OrganizationException;

    /**
     * 用给定的组织单元类型信息来创建一个组织单元类型。
     * @param organizationUnitType 将要新建的组织单元类型。
     * @throws ObjectAlreadyExistsException 假如要创建的组织单元类型已经存在。
     * @throws OrganizationException 包装了一个底层异常，比如底层数据源的异常，JNDI查找异常等等。
     * @throws IllegalArgumentException 假如参数organizationUnitType为null。
     */
    OrganizationUnitType createOrganizationUnitType(OrganizationUnitType
            organizationUnitType) throws ObjectAlreadyExistsException,
            OrganizationException;

    /**
     * 用给定的组织单元信息来创建一个组织单元。
     * @param organizationUnit 将要新建的组织单元
     * @return OrganizationUnit 在新建过程中可能会改变传入的组织单元,返回的组织单元是修改后的组织单元
     *@throws IllegalArgumentException 假如参数OrganizationUnit为null。
     * @throws ObjectAlreadyExistsException 假如要创建的组织单元已经存在。
     * @throws OrganizationException 包装了一个底层异常，比如底层数据源的异常，JNDI查找异常等等。
     */
    OrganizationUnit createOrganizationUnit(OrganizationUnit organizationUnit) throws
            ObjectAlreadyExistsException, OrganizationException;

    /**
     * 用给定的岗位类型信息来创建一个新的岗位类型。
     * @param positionType 将要新建的岗位类型
     * @return PositionType 在新建过程中可能会修改传入的岗位类型对象,返回修改后的岗位类型
     * @throws IllegalArgumentException 假如参数PositionType为null。
     * @throws ObjectAlreadyExistsException 假如要创建的岗位类型已经存在。
     * @throws OrganizationException 包装了一个底层异常，比如底层数据源的异常，JNDI查找异常等等。
     */
    PositionType createPositionType(PositionType positionType) throws
            ObjectAlreadyExistsException, OrganizationException;

    /**
     * 用给定的岗位信息来创建一个新的岗位。
     * @param position 将要新建的岗位
     * @return Position 在新建过程中可能会修改传入的岗位对象,返回修改后的岗位
     * @throws IllegalArgumentException 假如参数Position为null。
     * @throws ObjectAlreadyExistsException 假如要创建的岗位已经存在。
     * @throws OrganizationException 包装了一个底层异常，比如底层数据源的异常，JNDI查找异常等等。
     */
    Position createPosition(Position position) throws
            ObjectAlreadyExistsException, OrganizationException;

    /**
     * 用给定的角色类型来创建一个新的角色类型。
     * @param roleType 将要新建的角色类型信息
     * @return RoleType 在新建过程中可能会修改传入的角色类型对象,返回修改后的角色类型
     * @throws IllegalArgumentException 假如参数RoleType为null。
     * @throws ObjectAlreadyExistsException 假如要创建的角色类型已经存在。
     * @throws OrganizationException 包装了一个底层异常，比如底层数据源的异常，JNDI查找异常等等。
     */
    RoleType createRoleType(RoleType roleType) throws
            ObjectAlreadyExistsException, OrganizationException;

    /**
     * 用给定的角色来创建一个新的角色。
     * @param role 将要新建的角色信息
     * @return Role 在新建过程中可能会修改传入的角色对象,返回修改后的角色
     * @throws IllegalArgumentException 假如参数Role为null。
     * @throws ObjectAlreadyExistsException 假如要创建的角色已经存在。
     * @throws OrganizationException 包装了一个底层异常，比如底层数据源的异常，JNDI查找异常等等。
     */
    Role createRole(Role role) throws
            ObjectAlreadyExistsException, OrganizationException;

    /**
     * 用给定的工作组类型来创建一个新的工作组类型。
     * @param workGroupType 将要新建的工作组类型
     * @return WorkGroupType 在新建过程中可能会修改传入的工作组类型对象,返回修改后的工作组类型
     * @throws IllegalArgumentException 假如参数WorkGroupType为null。
     * @throws ObjectAlreadyExistsException 假如要创建的工作组类型已经存在。
     * @throws OrganizationException 包装了一个底层异常，比如底层数据源的异常，JNDI查找异常等等。
     */
    WorkGroupType createWorkGroupType(WorkGroupType workGroupType) throws
            ObjectAlreadyExistsException, OrganizationException;

    /**
     * 用给定的工作组来创建一个新的工作组。
     * @param role 将要新建的工作组信息
     * @return Role 在新建过程中可能会修改传入的工作组对象,返回修改后的工作组
     * @throws IllegalArgumentException 假如参数WorkGroup为null。
     * @throws ObjectAlreadyExistsException 假如要创建的工作组已经存在。
     * @throws OrganizationException 包装了一个底层异常，比如底层数据源的异常，JNDI查找异常等等。
     */
    WorkGroup createWorkGroup(WorkGroup workGroup) throws
            ObjectAlreadyExistsException, OrganizationException;

    /**
     * 用给定的职责来创建一个新的职责。
     * @param responsibility 将要新建的职责信息
     * @return Responsibility 在新建过程中可能会修改传入的职责对象,返回修改后的职责
     * @throws IllegalArgumentException 假如参数Responsibility为null。
     * @throws ObjectAlreadyExistsException 假如要创建的职责已经存在。
     * @throws OrganizationException 包装了一个底层异常，比如底层数据源的异常，JNDI查找异常等等。
     */
    Responsibility createResponsibility(Responsibility responsibility) throws
            ObjectAlreadyExistsException, OrganizationException;

    //---------------------------添加,指派类接口---------------------------------
    /**
     * 把一个雇员添加到一个组织单元。
     * <p>
     * 一个雇员添加到一个组织单元需要满足以下条件：
     * <li>添加的雇员要存在
     * <li>向其添加雇员的组织单元要存在
     * <li>雇员和组织单元要指定标识
     * <li>雇员没有属于某一个组织单元
     * </p>
     * @param employee Employee 将要添加的雇员
     * @param organization OrganizationUnit 要添加雇员的组织单元
     * @throws IllegalArgumentException 假如参数雇员或组织单元为null,或雇员，组织单元没有指定标识（ID）
     * @throws ObjectNotFoundException 假如雇员或组织单元不存在
     * @throws EmployeeAlreadyBelongedToOrganizationUnit 假如雇员已经属于某个组织单元
     * @throws OrganizationException  包装了一个底层异常，比如底层数据源的异常，JNDI查找异常等等。
     */
    void addEmployeeToOrganizationUnit(Employee employee,
                                       OrganizationUnit organization) throws
            ObjectNotFoundException, EmployeeAlreadyBelongedToOrganizationUnit,OrganizationException;


    /**
     *
     * 把一个雇员添加到工作组，并承担某种角色。
     * <p>
     * 一个雇员添加到一个工作组需要满足以下条件：
     * <li>添加的雇员要存在
     * <li>向其添加雇员的工作组要存在
     * <li>指定的角色要存在并属于该工作组
     * <li>雇员,组织和角色要指定标识
     * <li>雇员没有属于该工作组
     * </p

     * @param employee 将要添加到工作组的雇员
     * @param workGroup 将要向其添加雇员的工作组
     * @param roles 角色数组,雇员在工作组承担的角色
     * @throws IllegalArgumentException 假如
     * <li>参数雇员,工作组或角色数组为null
     * <li>角色数组长度为0
     * <li>雇员，组织单元没有指定标识（ID）,或角色数组中有元素没有指定标识
     * @throws ObjectNotFoundException 假如雇员,工作组或角色数组中的某元素(角色)不存在
     * @throws EmployeeAreadyBelongedToWorkGroup 假如雇员已经属于该工作组
     * @throws OrganizationException 包装了一个底层异常，比如底层数据源的异常，JNDI查找异常等等
     */
    void addEmployeeToWorkGroup(Employee employee, WorkGroup workGroup, Role[] roles) throws
            ObjectNotFoundException, EmployeeAlreadyBelongedToWorkGroup,OrganizationException;

    /**
     * 将一个已存在的职责<i>responsibility</i>添加到岗位<i>position</i>。
     * 添加职责需要满足如下条件：
     * <p>
     * <li>要添加的职责和岗位要存在；
     * <li>岗位和职责属于同一个组织单元或者定义职责的组织单元是定义岗位的组织单元的上级；
     * <li>该岗位还没有要添加的职责。
     * </p>
     * @param responsibility Responsibility
     * @param position Position
     * @throws ObjectNotFoundException
     * @throws OrganizationException 包装了一个底层异常，比如底层数据源的异常，JNDI查找异常等等
     */
    void addResponsibilityToPosition(Responsibility responsibility,
                                     Position position) throws
            ObjectNotFoundException, OrganizationException;
    /**
     *
     * @param responsibility 要添加给角色的职责
     * @param role 要向其添加职责的角色
     * @throws ObjectNotFoundException  若职责或角色不存在
     * @throws OrganizationException  包装了一个底层异常，比如底层数据源的异常，JNDI查找异常等等
     */
    void addResponsibilityToRole(Responsibility responsibility, Role role) throws
            ObjectNotFoundException, OrganizationException;

    /**
     * 给雇员<li>employee</li>分派一个岗位<li>position</li>。
     *
     * 给雇员分派一个岗位需要满足的条件：
     * <li>雇员和岗位指定了标识
     * <li>雇员和岗位存在
     * <li>岗位属于该雇员所在的组织单元
     * <li>雇员还没有承担该岗位
     *
     * @param position 要分派给雇员的岗位
     * @param employee 将要被分派岗位的雇员
     * @throws IllegalArgumentException 假如参数岗位或雇员为null，或岗位，雇员没有指定标识
     * @throws ObjectNotFoundException 假如岗位或雇员不存在
     * @throws OrganizationException 包装了一个底层异常，比如底层数据源的异常，JNDI查找异常等等
     */
    void assignPositionToEmployee(Position position, Employee employee) throws
            ObjectNotFoundException, OrganizationException;

    /**
     * 给工作组中的成员指派一个角色。
     * 给工作组中的成员指派一个角色要满足如下条件：
     * <li>角色要存在
     * <li>角色要属于该工作组
     * <li>工作组要存在
     * <li>雇员要存在
     * <li>雇员在该工作组没有承担该角色
     *
     * @param role 将要分派的角色
     * @param employee 给定的雇员
     * @param workGroup 给定的工作组
     * @throws IllegalArgumentException 假如
     * <li>参数角色，雇员或工作组为null
     * <li>参数角色，雇员或工作组没有指定标识
     * @throws ObjectNotFoundException
     * @throws OrganizationException 包装了一个底层异常，比如底层数据源的异常，JNDI查找异常等等
     */
    void assignRoleToEmployee(Role role, Employee employee, WorkGroup workGroup) throws
            ObjectNotFoundException, OrganizationException;

    //----------------------------删除类接口------------------------------------－
    /**
     *
     *删除雇员。若真正彻底删除的标志设置为true,则彻底删除雇员（即从存储介质中删除），同时把与雇员相关联的关系也删除，若为false则仅把雇员置为
     * 不可用，同时把与其相关联的关系全部删除。
     *
     * @param employee Employee
     * @param realDeleted 真正彻底删除的标志
     * @throws IllegalArgumentException 假如
     * <li>参数中雇员为null
     * <li>参数中雇员没有指定标识
     * @throws ObjectNotFoundException 假如雇员不存在
     * @throws OrganizationException 包装了一个底层异常，比如底层数据源的异常，JNDI查找异常等等
     */
    void deleteEmployee(Employee employee, boolean realDeleted) throws ObjectNotFoundException,
            OrganizationException;

    /**
     * 删除组织单元类型。
     *
     * @param organizationUnitType 将要被删除的组织单元类型
     * @throws IllegalArgumentException 假如组织单元类型为null或组织单元类型没有指定标识
     * @throws ObjectNotFoundException 假如组织单元类型不存在
     * @throws AlreadyExistedOrgUntiTypeAssociationWithOrgUnit  假如存在于该组织单元关联的组织单元
     * @throws OrganizationException  包装了一个底层异常，比如底层数据源的异常，JNDI查找异常等等
     */
    void deleteOrganizationUnitType(OrganizationUnitType organizationUnitType) throws
            ObjectNotFoundException,AlreadyExistedOrgUntiTypeAssociationWithOrgUnit, OrganizationException;
    /**
     * 删除组织单元。删除组织单元就会同时删除该组织单元定义的岗位，关联的雇员和子组织单元
     * @throws IllegalArgumentException 假如组织单元为null或组织单元没有指定标识
     * @param organizationUnit 将要被删除的组织单元
     * @throws ObjectNotFoundException 假如组织单元不存在
     * @throws OrganizationException 包装了一个底层异常，比如底层数据源的异常，JNDI查找异常等等
     */
    void deleteOrganizationUnit(OrganizationUnit organizationUnit) throws
            ObjectNotFoundException, OrganizationException;
    /**
     * 删除岗位类型。
     * <pr>
     * 删除岗位类型要满足的条件：
     * <li>该岗位类型不是内置岗位即领导岗位类型
     * <li>该岗位类型没有与任何岗位关联
     * </pr>
     * @param positionType 待删除的岗位类型
     * @throws IllegalArgumentException 假如参数岗位类型为null或岗位类型没有指定标识
     * @throws ObjectNotFoundException 假如岗位类型不存在
     * @throws InvalidPositionTypeException 假如
     * <li> 岗位类型为内置岗位类型,即领导岗位类型
     * <li> 岗位类型与岗位有关联
     * @throws OrganizationException 包装了一个底层异常，比如底层数据源的异常，JNDI查找异常等等
     */
    void deletePostionType(PositionType positionType) throws
            ObjectNotFoundException, InvalidPositionTypeException ,OrganizationException;

    /**
     *
     * 删除岗位。
     *
     * @param positionId 将要被删除的岗位的标识
     * @throws IllegalArgumentException  假如参数岗位标识为null
     * @throws ObjectNotFoundException 假如岗位标识对应的岗位不存在
     * @throws OrganizationException 包装了一个底层异常，比如底层数据源的异常，JNDI查找异常等等
     */
    void deletePosition(String positionId) throws ObjectNotFoundException,
            OrganizationException;
    /**
     *删除角色类型。
     *
     * @param roleTypeId 将要被删除的角色类型的标识
     * @throws IllegalArgumentException 假如参数角色类型
     * @throws ObjectNotFoundException 假如角色类型不存在
     * @throws OrganizationException 包装了一个底层异常，比如底层数据源的异常，JNDI查找异常等等
     */
    void deleteRoleType(String roleTypeId) throws ObjectNotFoundException,
            OrganizationException;
    /**
     *删除角色。
     * @param roleId 将要删除的角色的标识
     * @throws IllegalArgumentException 假如参数角色标识为null
     * @throws ObjectNotFoundException  假如角色不存在
     * @throws OrganizationException 包装了一个底层异常，比如底层数据源的异常，JNDI查找异常等等
     */
    void deleteRole(String roleId) throws ObjectNotFoundException,
            OrganizationException;
    /**
     * 删除工作组类型。
     *
     * @param workGroupTypeId 将要被删除的工作组类型的标识
     * @throws IllegalArgumentException 假如参数工作组类型标识为null
     * @throws ObjectNotFoundException 假如工作组类型不存在
     * @throws OrganizationException 包装了一个底层异常，比如底层数据源的异常，JNDI查找异常等等
     */
    void deleteWorkGroupType(String workGroupTypeId) throws
            ObjectNotFoundException, OrganizationException;
    /**
     * 删除工作组。删除工作组时，同时会删除该工作组下面的子工作组＆相关的关联信息。
     *
     * @param workGroupId 待删除的工作组的标识
     * @throws IllegalArgumentException 假如参数工作组标识为null
     * @throws ObjectNotFoundException 假如工作组标识对应的工作组不存在
     * @throws OrganizationException 包装了一个底层异常，比如底层数据源的异常，JNDI查找异常等等
     */
    void deleteWorkGroup(String workGroupId) throws ObjectNotFoundException,
            OrganizationException;
    /**
     * 删除职责。删除职责时会同时删除与其关联的信息。
     *
     * @param responsibilityId 将要被删除的职责的标识
     * @throws IllegalArgumentException 假如参数职责标识为null
     * @throws ObjectNotFoundException 假如职责不存在
     * @throws OrganizationException 包装了一个底层异常，比如底层数据源的异常，JNDI查找异常等等
     */
    void deleteResponsibility(String responsibilityId) throws
            ObjectNotFoundException, OrganizationException;


    //----------------------------移除类接口-------------------------------------
    /**
     * 把雇员从组织单元中移出，假如雇员属于组织单元。
     * @param employee 将要从组织单元中移出出去的雇员
     * @param organization 将要从其移出雇员的组织单元
     * @throws IllegalArgumentException 假如参数中雇员或组织单元为null，或者雇员或组织单元没有指定标识
     * @throws ObjectNotFoundException 假如雇员或组织单元不存在
     * @throws OrganizationException  包装了一个底层异常，比如底层数据源的异常，JNDI查找异常等等
     */
    void removeEmployeeFromOrganizationUnit(Employee employee,
                                            OrganizationUnit organizationUnit) throws
            ObjectNotFoundException, OrganizationException;
    /**
     *
     * 将一个已经存在于工作组<i>workGroup</i>的成员（雇员）从工作组移出。
     *
     *
     * 移出雇员要满足的条件：
     * <li>雇员和工作组存在
     * <li>雇员和工作组指定了标识
     * <li>雇员是工作组的成员
     * <li>
     * @param employee 将被从工作组中移出出去的雇员
     * @param workGroup 将从其移出雇员的工作组
     * @throws IllegalArgumentException 假如参数雇员（或工作组）为null，或者雇员（或工作组）没有指定标识
     * @throws ObjectNotFoundException 假如雇员或工作组不存在
     * @throws OrganizationException 包装了一个底层异常，比如底层数据源的异常，JNDI查找异常等等
     */
    void removeEmployeeFromWorkGroup(Employee employee, WorkGroup workGroup) throws
            ObjectNotFoundException, OrganizationException;

    /**
     * 从岗位中移出职责。
     *
     * @param responsibility 将被从岗位中移出出去的职责
     * @param position 给定的职责
     * @throws IllegalArgumentException 假如参数职责或岗位为null，或者职责或岗位未指定标识
     * @throws ObjectNotFoundException 假如岗位或职责不存在
     * @throws OrganizationException 包装了一个底层异常，比如底层数据源的异常，JNDI查找异常等等
     */
    void removeResponsibilityFromPosition(Responsibility responsibility,
                                          Position position) throws
            ObjectNotFoundException, OrganizationException;
    /**
     *将一个已经存在的职责<i>responsibility<i>从给定的角色<i>role</i>中移出出去,即该角色不在承担此职责。
     *
     * 从角色中移出职责要满足如下条件：
     * <li>角色＆职责指定了标识
     * <li>角色＆职责存在
     * <li>角色承担了此职责
     *
     * @param responsibility 将被从角色中移出出去的职责
     * @param role 将从其中移出职责的角色
     * @throws IllegalArgumentException 假如参数职责或角色为null，或者职责或角色没有指定标识
     * @throws ObjectNotFoundException 假如职责或角色不存在
     * @throws OrganizationException 包装了一个底层异常，比如底层数据源的异常，JNDI查找异常等等
     */
    void removeResponsibilityFromRole(Responsibility responsibility, Role role) throws
            ObjectNotFoundException, OrganizationException;
    /**
     *
     * 从雇员中移出在某工作组中承担的角色。
     *
     * 移出雇员在某工作组承担的角色要满足如下条件：
     * <li>角色，雇员＆工作组都指定了标识
     * <li>角色，雇员＆工作组都存在
     * <li>角色属于该工作组
     * <li>雇员是该项目组的成员
     * @throws IllegalArgumentException 假如雇员（角色，工组组）不存在，或者雇员（角色，工组组）没有指定标识
     * @param role 将被从雇员中移出的角色
     * @param employee 将从其移出角色的雇员
     * @param workGroup WorkGroup 给定的工作组
     * @throws ObjectNotFoundException 假如角色，雇员或工作组不存在
    void removeRoleFromEmployee(Role role, Employee employee,
    WorkGroup workGroup) throws
ObjectNotFoundException, OrganizationException;


/**
* 从雇员移出岗位，即解除雇员承担某岗位。
* @param position 将要从雇员中移出出去的岗位
* @param employee 将要从其移出岗位的雇员
* @throws IllegalArgumentException 假如雇员或岗位不存在，或者雇员（岗位）未指定标识
* @throws ObjectNotFoundException 假如雇员或岗位不存在
* @throws OrganizationException 包装了一个底层异常，比如底层数据源的异常，JNDI查找异常等等
*/
void removePositionFromEmployee(Position position, Employee employee) throws
ObjectNotFoundException, OrganizationException;

//----------------------------修改类接口-------------------------------------
/**
* 修改雇员基本信息。
* @param employee 待修改的雇员信息
* @return Employee 修改以后的雇员
* @throws IllegalArgumentException 假如雇员为null，或雇员没有指定标识
* @throws ObjectNotFoundException 假如雇员不存在
* @throws OrganizationException 包装了一个底层异常，比如底层数据源的异常，JNDI查找异常等等
*/
Employee modifyEmployee(Employee employee) throws ObjectNotFoundException,
OrganizationException;

/**
* 修改组织单元类型基本信息。
*
* @param organizationUnitType 待修改的组织单元类型
* @return OrganizationUnitType 组织单元类型
* @throws IllegalArgumentException  假如参数组织单元类型为null或组织单元类型没有指定标识
* @throws ObjectNotFoundException 假如组织单元类型不存在
* @throws OrganizationException 包装了一个底层异常，比如底层数据源的异常，JNDI查找异常等等
*/
OrganizationUnitType modifyOrganizationUnitType(OrganizationUnitType
organizationUnitType) throws ObjectNotFoundException,
OrganizationException;

/**
* 修改组织单元。
* @param organizationUnit 待修改的组织单元
* @return OrganizationUnit 组织单元
* @throws IllegalArgumentException 假如组织单元为null，或组织单元没有指定标识
* @throws ObjectNotFoundException 假如组织单元不存在
* @throws OrganizationException 包装了一个底层异常，比如底层数据源的异常，JNDI查找异常等等
*/
OrganizationUnit modifyOrganizationUnit(OrganizationUnit organizationUnit) throws
ObjectNotFoundException, OrganizationException;

/**
* 修改岗位类型
* 修改岗位类型满足的条件：
* <li>岗位类型不是内置的岗位类型，即领导岗位类型
* @param positionType PositionType
* @return PositionType
*
* @throws IllegalArgumentException  假如岗位类型为null或岗位类型没有指定标识
* @throws ObjectNotFoundException 假如岗位类型不存在
* @throws InvalidPositionTypeException 假如岗位类型为内置岗位类型
* @throws OrganizationException 包装了一个底层异常，比如底层数据源的异常，JNDI查找异常等等
*/
PositionType modifyPostionType(PositionType positionType) throws
ObjectNotFoundException,InvalidPositionTypeException, OrganizationException;
/**
* 修改岗位信息。
*
* @param position 待修改的岗位
* @return Position 修改后的岗位
* @throws IllegalArgumentException 假如参数岗位为null或岗位未指定标识
* @throws ObjectNotFoundException 假如岗位不存在
* @throws OrganizationException 包装了一个底层异常，比如底层数据源的异常，JNDI查找异常等等
*/
Position modifyPosition(Position position) throws ObjectNotFoundException,
OrganizationException;
/**
* 修改角色类型。
*
* @param roleType RoleType
* @return RoleType
* @throws IllegalArgumentException 假如角色类型为null或角色没有指定标识
* @throws ObjectNotFoundException  假如角色类型不存在
* @throws InvalidRoleTypeException 假如角色类型为内置角色类型，例如领导角色类型
* @throws OrganizationException  包装了一个底层异常，比如底层数据源的异常，JNDI查找异常等等
*/
RoleType modifyRoleType(RoleType roleType) throws ObjectNotFoundException, InvalidRoleTypeException,
OrganizationException;
/**
* 修改角色。
*
* @param role 待修改的角色
* @return Role 角色
* @throws IllegalArgumentException 假如角色为null或角色没有指定标识
* @throws ObjectNotFoundException 假如角色不存在
* @throws OrganizationException  包装了一个底层异常，比如底层数据源的异常，JNDI查找异常等等
*/
Role modifyRole(Role role) throws ObjectNotFoundException,
OrganizationException;
/**
* 修改工作组类型。
*
* @param  workGroupType 待修改的工作组类型
* @return WorkGroupType 工作组类型
* @throws IllegalArgumentException 假如工作组类型为null或工作组类型没有指定标识
* @throws ObjectNotFoundException 假如工作组类型不存在
* @throws OrganizationException 包装了一个底层异常，比如底层数据源的异常，JNDI查找异常等等
*/
WorkGroupType modifyWorkGroupType(WorkGroupType workGroupType) throws
ObjectNotFoundException, OrganizationException;
/**
* 修改工作组。
*
* @param workGroup 待修改的工作组
* @return WorkGroup 工作组
* @throws IllegalArgumentException 假如参数工作组为null或工作组没有指定标识
* @throws ObjectNotFoundException 假如工作组不存在
* @throws OrganizationException 包装了一个底层异常，比如底层数据源的异常，JNDI查找异常等等
*/
WorkGroup modifyWorkGroup(WorkGroup workGroup) throws
ObjectNotFoundException, OrganizationException;
/**
*修改职责信息。
* @param responsibility 将要修改的职责
* @return Responsibility 返回修改后的职责
* @throws IllegalArgumentException 假如参数职责为null或职责未指定标识
* @throws ObjectNotFoundException 假如职责不存在
* @throws OrganizationException 包装了一个底层异常，比如底层数据源的异常，JNDI查找异常等等
*/
Responsibility modifyResponsibility(Responsibility responsibility) throws
ObjectNotFoundException, OrganizationException;


//-----------------------查询接口--------------------------------------------

//---------------------查询类接口-根据ID查询---------------------------------－

/**
*返回雇员标识对应的雇员
* @param employeeid 雇员标识
* @return Employee 雇员标识对应的雇员
* @throws IllegalArgumentException 假如参数雇员标识为null
* @throws ObjectNotFoundException 假如雇员不存在
* @throws OrganizationException 包装了一个底层异常，比如底层数据源的异常，JNDI查找异常等等
*/
Employee getEmployee(String employeeid) throws ObjectNotFoundException,
OrganizationException;
/**
* 返回组织单元类型标识对应的组织单元类型
*
* @param organiztionUnitTypeId 组织单元类型标识
* @return OrganizationUnitType 组织单元类型能够
* @throws IllegalArgumentException 假如参数组织单元标识为null
* @throws ObjectNotFoundException  假如组织单元类型
* @throws OrganizationException 包装了一个底层异常，比如底层数据源的异常，JNDI查找异常等等
*/
OrganizationUnitType getOrganizationUnitType(String organiztionUnitTypeId) throws
ObjectNotFoundException, OrganizationException;
/**
*  返回组织单元标识对应的组织单元。
*
* @param organizationUnitId 给定的组织单元标识
* @return OrganizationUnit 给定组织单元标识对应的组织单元
* @throws IllegalArgumentException  假如组织单元标识为null
* @throws ObjectNotFoundException  假如组织单元不存在
* @throws OrganizationException 包装了一个底层异常，比如底层数据源的异常，JNDI查找异常等等
*/
OrganizationUnit getOrganizationUnit(String organizationUnitId) throws
ObjectNotFoundException, OrganizationException;
/**
*
* 返回岗位类型标识对应的岗位。
*
* @param positionTypeId 岗位类型标识
* @return PositionType 岗位类型标识对应的岗位类型
* @throws IllegalArgumentException 假如岗位类型标识为null
* @throws ObjectNotFoundException  假如岗位类型不存在
* @throws OrganizationException 包装了一个底层异常，比如底层数据源的异常，JNDI查找异常等等
*/
PositionType getPostionType(String positionTypeId) throws
ObjectNotFoundException, OrganizationException;
/**
* 返回岗位标识对应的岗位。

* @param positionId 给定的岗位标识
* @return Position 岗位标识对应的岗位
* @throws IllegalArgumentException 假如参数岗位标识为null
* @throws ObjectNotFoundException 假如岗位不存在
* @throws OrganizationException 包装了一个底层异常，比如底层数据源的异常，JNDI查找异常等等
*/
Position getPosition(String positionId) throws ObjectNotFoundException,
OrganizationException;
/**
*返回角色类型标识对应的角色标识
*
* @param roleTypeId 角色类型标识
* @return RoleType 角色类型
* @throws IllegalArgumentException 假如参数角色类型标识为null
* @throws ObjectNotFoundException 假如角色类型不存在
* @throws OrganizationException 包装了一个底层异常，比如底层数据源的异常，JNDI查找异常等等
*/
RoleType getRoleType(String roleTypeId) throws ObjectNotFoundException,
OrganizationException;
/**
*返回角色标识对应的角色。
*
* @param roleId 角色标识
* @return Role 角色标识对应的角色
* @throws IllegalArgumentException 假如参数角色标识为null
* @throws ObjectNotFoundException  假如角色不存在
* @throws OrganizationException 包装了一个底层异常，比如底层数据源的异常，JNDI查找异常等等
*/
Role getRole(String roleId) throws ObjectNotFoundException,
OrganizationException;
/**
*返回工作组类型标识对应的工作组类型。
*
* @param workGroupTypeId 工作组类型标识
* @return WorkGroupType 工作组类型标识对应的工作组类型
* @throws IllegalArgumentException 假如参数工作组类型标识为null
* @throws ObjectNotFoundException 假如工作组类型不存在
* @throws OrganizationException 包装了一个底层异常，比如底层数据源的异常，JNDI查找异常等等
*/
WorkGroupType getWorkGroupType(String workGroupTypeId) throws
ObjectNotFoundException, OrganizationException;
/**
*返回工作组标识对应的工作组。
*
* @param workGroupId 工作组标识
* @return WorkGroup 工作组标识对应的工作组
* @throws IllegalArgumentException 假如参数工作组标识为null
* @throws ObjectNotFoundException  假如工作组不存在
* @throws OrganizationException 包装了一个底层异常，比如底层数据源的异常，JNDI查找异常等等
*/
WorkGroup getWorkGroup(String workGroupId) throws ObjectNotFoundException,
OrganizationException;
/**
*返回职责标识对应的职责。
*
* @param responsibilityId 角色标识
* @return Responsibility 角色标识对应的标识
* @throws IllegalArgumentException 假如参数职责标识为null
* @throws ObjectNotFoundException 假如职责不存在
* @throws OrganizationException 包装了一个底层异常，比如底层数据源的异常，JNDI查找异常等等
*/
Responsibility getResponsibility(String responsibilityId) throws
ObjectNotFoundException, OrganizationException;

//--------------------------查询类接口-查询所有-------------------------------－－－－－－

/**
* 获取所有雇员的列表。
* @return  所有雇员的数组，没有排序，若没有雇员则返回一个空数组。
* @throws OrganizationException 包装了一个底层异常，比如底层数据源的异常，JNDI查找异常等等。
*/
Employee[] getAllEmployees() throws OrganizationException;

/**
* 获取所有组织单元类型的列表。
* @return  所有组织单元类型的数组，没有排序，若没有组织单元类型则返回一个空数组。
* @throws OrganizationException 包装了一个底层异常，比如底层数据源的异常，JNDI查找异常等等。
*/
OrganizationUnitType[] getAllOrganizationUnitTypes() throws
OrganizationException;

/**
* 获取所有组织单元的列表。
* @return  所有组织单元的数组，没有排序，若没有组织单元则返回一个空数组。
* @throws OrganizationException 包装了一个底层异常，比如底层数据源的异常，JNDI查找异常等等。
*/
OrganizationUnit[] getAllOrganizationUnits() throws OrganizationException;
/**
*
*  返回所有岗位类型。
*
* @return PositionType[] 所有岗位类型的数组
* @throws OrganizationException 包装了一个底层异常，比如底层数据源的异常，JNDI查找异常等等
*/
PositionType[] getAllPositionTypes() throws OrganizationException;
/**
*返回所有岗位。
*
* @return Position[] 所有岗位的数组
* @throws OrganizationException 包装了一个底层异常，比如底层数据源的异常，JNDI查找异常等等
*/
Position[] getAllPositions() throws OrganizationException;
/**
*返回所有角色类型。
* @return RoleType[] 所有角色类型的数组。
* @throws OrganizationException 包装了一个底层异常，比如底层数据源的异常，JNDI查找异常等等
*/
RoleType[] getAllRoleTypes() throws OrganizationException;
/**
* 返回所有角色。
* @return Role[] 所有角色的数组。
* @throws OrganizationException 包装了一个底层异常，比如底层数据源的异常，JNDI查找异常等等
*/
Role[] getAllRoles() throws OrganizationException;
/**
*返回所有工作组类型。
*
* @return WorkGroupType[] 所有工作组类型的数组。
* @throws OrganizationException 包装了一个底层异常，比如底层数据源的异常，JNDI查找异常等等
*/
WorkGroupType[] getAllWorkGroupTypes() throws OrganizationException;
/**
*返回所有工作组。
* @return WorkGroup[] 所有工作组的数组。
* @throws OrganizationException 包装了一个底层异常，比如底层数据源的异常，JNDI查找异常等等
*/
WorkGroup[] getAllWorkGroups() throws OrganizationException;
/**
*返回所有职责。
* @return Responsibility[] 包含所有职责的数组。
* @throws OrganizationException 包装了一个底层异常，比如底层数据源的异常，JNDI查找异常等等
*/
Responsibility[] getAllResponsibilities() throws OrganizationException;

//---------------------查询类接口-根据条件查询---------------------------------

/**
* 若直接属于组织单元标志<li>isDirect<li>为true，则仅返回直接属于该组织单元的雇员，若为false，则返回
* 该组织单元的所有雇员，包括直接属于该组织单元＆该子组织单元的雇员。
*
* 例如：
* 一个组织单元结构若下
* <pre>
*                               组织单元A（张三）
*                                  |
*                           --- －－－－－－－
*                           |             |
*                      组织单元B（李四）  组织单元C（王五）
*
* 若直接属于组织单元标志为true，则只返回包含张三的雇员数组，若为false则返回包含张三，李四＆王五的雇员数组。
*
* </pre>
* @param organizationUnitId 给定组织单元的Id
* @param isDirect boolean
* @return Employee[]
* @throws ObjectNotFoundException
* @throws OrganizationException
*/
Employee[] getEmployeesOfOrganizationUnit( String organizationUnitId,
                  boolean isDirect) throws
ObjectNotFoundException, OrganizationException;


/**
* 返回所有给定组织单元的子组织单元。
*
* @param organizationUnitId 给定组织单元的Id
* @return OrganizationUnit[] 属于给定组织单元的子组织单元数组，若没有子组织单元，则返回空数组
* @throws IllegalArgumentException 若参数组织单元Id为null，或organizationUnitId.trim().length()=0
* @throws ObjectNotFoundException 假如给定组织单元Id对应的组织单元不存在
* @throws OrganizationException 包装了一个底层异常，比如底层数据源的异常，JNDI查找异常等等。
*/
OrganizationUnit[] getChildOrganizationUnits(String organizationUnitId
                     ) throws
ObjectNotFoundException, OrganizationException;


/**
* 返回给定组织单元所有的岗位。
* @param organizationUnitId 给定组织单元的标识
* @return Position[] 包含给定组织单元所有岗位的岗位数组
* @throws IllegalArgumentException 假如参数组织单元标识未null
* @throws ObjectNotFoundException 假如组织单元不存在
* @throws OrganizationException 包装了一个底层异常，比如底层数据源的异常，JNDI查找异常等等
*/
Position[] getPositionsOfOrganizationUnit(String organizationUnitId) throws
ObjectNotFoundException, OrganizationException;
/**
*返回给定工作组的定义的角色。
*
* @param workGroupId 给定的工作组的标识
* @return Role[] 包含给定工作组定义的角色数组
* @throws IllegalArgumentException 假如参数工作组标识为null
* @throws ObjectNotFoundException  假如工作组不存在
* @throws OrganizationException 包装了一个底层异常，比如底层数据源的异常，JNDI查找异常等等
*/
Role[] getRolesOfWorkGroup(String workGroupId) throws
ObjectNotFoundException, OrganizationException;
/**
*返回雇员在某项目组承担的角色。
*
* @param employeeId 雇员标识
* @param workGroupId 给定工作组的标识
* @return Role[] 包含雇员承担角色的角色数组
* @throws IllegalArgumentException 假如参数雇员标识或工作组标识为null
* @throws ObjectNotFoundException 假如雇员或工作组不存在
* @throws OrganizationException 包装了一个底层异常，比如底层数据源的异常，JNDI查找异常等等
*/
Role[] getRolesOfEmployee(String employeeId, String workGroupId) throws
ObjectNotFoundException, OrganizationException;
/**
* 返回雇员承担的所有岗位。
*
* @param employeeId 雇员标识
* @return Position[] 返回雇员承担的所有岗位数组
* @throws IllegalArgumentException  假如参数雇员标识为null
* @throws ObjectNotFoundException 假如雇员标识对应的雇员不存在
* @throws OrganizationException 包装了一个底层异常，比如底层数据源的异常，JNDI查找异常等等。
*/
Position[] getPositionsOfEmployee(String employeeId) throws
ObjectNotFoundException, OrganizationException;
/**
* 返回给定角色承担的职责。
*
* @param roleId 给定的角色的标识
* @return Responsibility[] 职责数组
* @throws IllegalArgumentException 假如参数角色标识为null
* @throws ObjectNotFoundException  假如角色不存在
* @throws OrganizationException 包装了一个底层异常，比如底层数据源的异常，JNDI查找异常等等。
*/
Responsibility[] getResponsibilitiesOfRole(String roleId) throws
ObjectNotFoundException, OrganizationException;
/**
*返回给定岗位承担的职责。
* @param positionId 给定岗位的岗位标识
* @return Responsibility[] 返回给定岗位的所承担的所有职责的数组。
* @throws IllegalArgumentException 假如参数岗位标识为null
* @throws ObjectNotFoundException 假如给定岗位的岗位标识对应的岗位不存在
* @throws OrganizationException 包装了一个底层异常，比如底层数据源的异常，JNDI查找异常等等
*/
Responsibility[] getResponsibilitiesOfPosition(String positionId) throws
ObjectNotFoundException, OrganizationException;


//---------------------------------判断类接口--------------------------------
/**
*
* 返回true，若雇员属于组织单元。
* @param employee 待判断其是否属于组织单元的雇员
* @param organizationUnit 待判断其是否有某雇员的组织单元
* @return boolean
* @throws IllegalArgumentException 假如
* <li>参数雇员或组织单元为null
* <li>参数雇员或组织单元没有指定标识
* @throws ObjectNotFoundException 假如雇员或组织单元不存在
* @throws OrganizationException 包装了一个底层异常，比如底层数据源的异常，JNDI查找异常等等
*/
boolean isEmployeeBelongsToOrganizationUnit(Employee employee,
                    OrganizationUnit
                    organizationUnit) throws
ObjectNotFoundException, OrganizationException;

/**
* 返回true，若雇员属于某工作组。
* @param employee 待判断其是否属于某工作组的雇员
* @param workGroup 待判断雇员是否属于其的工作组
* @return boolean
* @throws IllegalArgumentException 假如
* <li>参数雇员或工作组为null
* <li>参数雇员或工作组没有指定标识
* @throws ObjectNotFoundException 假如雇员或工作组不存在
* @throws OrganizationException 包装了一个底层异常，比如底层数据源的异常，JNDI查找异常等等
*/
boolean isEmployeeBelongsToWorkGroup(Employee employee, WorkGroup workGroup) throws
ObjectNotFoundException, OrganizationException;

/**
* 返回true，若组织单元定义了（有）某岗位
* @param organizationUnit 待判断其是否有某岗位的组织单元。
* @param position 待判断其是否属于某组织单元的岗位
* @return boolean
* @throws IllegalArgumentException 假如
* <li>参数组织单元或岗位为null
* <li>参数组织单元或岗位没有指定标识
* @throws ObjectNotFoundException 假如组织单元或岗位不存在
* @throws OrganizationException 包装了一个底层异常，比如底层数据源的异常，JNDI查找异常等等
*/
boolean isOrganizationUnitHasPosition(OrganizationUnit organizationUnit,
              Position position) throws
ObjectNotFoundException, OrganizationException;

/**
* 返回true，若工作组定义（有）某角色。
* @param workGroup 待判断其是否有某角色的工作组
* @param role 待判断其是否属于某工作组的角色
* @return boolean
* @throws IllegalArgumentException 假如
* <li>参数工作组或角色为null
* <li>参数工作组或角色没有指定标识
* @throws ObjectNotFoundException 假如工作组或角色不存在
* @throws OrganizationException 包装了一个底层异常，比如底层数据源的异常，JNDI查找异常等等
*/
boolean isWorkGroupHasRole(WorkGroup workGroup, Role role) throws
ObjectNotFoundException, OrganizationException;

/**
* 返回true，若岗位承担某职责。
* @param position 岗位
* @param responsibility 职责
* @return boolean
* @throws IllegalArgumentException 假如
* <li>参数岗位或职责为null
* <li>参数岗位或职责没有指定标识
* @throws ObjectNotFoundException 假如岗位或职责不存在
* @throws OrganizationException  包装了一个底层异常，比如底层数据源的异常，JNDI查找异常等等
*/
boolean isPositionHasResponsibility(Position position,
            Responsibility responsibility) throws
ObjectNotFoundException, OrganizationException;

/**
* 返回true，若角色承担某职责。
* @param role 角色
* @param responsibility 职责
* @return boolean
* @throws IllegalArgumentException 假如
* <li>参数角色或职责为null
* <li>参数角色或职责没有指定标识
* @throws ObjectNotFoundException 假如角色或职责不存在
* @throws OrganizationException 包装了一个底层异常，比如底层数据源的异常，JNDI查找异常等等
*/
boolean isRoleHasResponsibility(Role role, Responsibility responsibility) throws
ObjectNotFoundException, OrganizationException;

/**
* 返回true，若雇员在工作组承担某角色。
* @param employee 雇员
* @param role 角色
* @param workGroup 工作组
* @return boolean
* @throws IllegalArgumentException 假如
* <li>参数雇员，角色或工作组为null
* <li>参数雇员，角色或工作组没有指定标识
* @throws ObjectNotFoundException 假如雇员，角色或工作组不存在
* @throws OrganizationException 包装了一个底层异常，比如底层数据源的异常，JNDI查找异常等等
*/
boolean isEmployeeHasRoleInsideWorkGroup(Employee employee, Role role,
                 WorkGroup workGroup) throws
ObjectNotFoundException, OrganizationException;

/**
* 返回true，若雇员承担该岗位。
*
* @param employee
* @param position
* @return boolean
*
* @throws ObjectNotFoundException
* @throws OrganizationException
*/
boolean isEmployeeHasPosition(Employee employee, Position position) throws
ObjectNotFoundException, OrganizationException;

/**
* 通过此接口获得的行政直接领导要满足如下规则
<li> 一个人的行政直接领导最多只有一个
<li>若一个人在某个组织单元没有担任负责岗位,那么他(或她)的行政直接领导就是在同一组织单元担任负责岗位的人
<li>若一个人在某个组织单元中担任负责岗位
<br> 1) 假如他所在的组织单元有上级组织单元,那么他的行政直接领导就是在上级组织单元中担任负责岗位的人,
<br> 2) 否则他没有行政直接上级。


* @param employeeid 要查找其行政直接上级的雇员编号
* @return Employee 是雇员(编号为employeeid)的行政直接上级的雇员
* @throws OrganizationException
*/
Employee getAdministrativeDirectLeader(String employeeid) throws
OrganizationException;

/**
* 通过此接口获得的行政直接领导要满足如下规则
<li> 一个人的行政直接领导最多只有一个
<li>若一个人在某个组织单元没有担任负责岗位,那么他(或她)的行政直接领导就是在同一组织单元担任负责岗位的人
<li>若一个人在某个组织单元中担任负责岗位
<br> 1) 假如他所在的组织单元有上级组织单元,那么他的行政直接领导就是在上级组织单元中担任负责岗位的人,
<br> 2) 否则他没有行政直接上级。

* @param subordinate Employee
* @return Employee
* @throws OrganizationException
*/
Employee getAdministrativeDirectLeader(Employee subordinate) throws
OrganizationException;

/**
* 业务直接领导满足如下规则
<li>一个人可以有多个业务直接领导
<li> 一个人在工作组(业务组织单元)中没有担任负责角色,那么他的业务直接领导就是在同一业务单元中担任负责角色的人。
<li> 若一个人在某个业务组织单元中担任负责角色
<br>1) 假如他所在的业务单元有上级业务组织单元,那么他的业务直接领导就是在上级业务组织单元中担任负责角色的人,
<br>2) 否则他没有业务直接上级。

* @param employeeid 要查找其业务直接上级的雇员编号
* @param workgroupids String[]
* @return BusinessLeader[] 业务领导数组,业务领导包含工作组和雇员
* @throws OrganizationException
*/
BusinessLeader[] getBusinessDirectLeaders(String employeeid,
                  String[] workgroupids) throws
OrganizationException;

/**
* 业务直接领导满足如下规则
<li>一个人可以有多个业务直接领导
<li> 一个人在工作组(业务组织单元)中没有担任负责角色,那么他的业务直接领导就是在同一业务单元中担任负责角色的人。
<li> 若一个人在某个业务组织单元中担任负责角色
<br>1) 假如他所在的业务单元有上级业务组织单元,那么他的业务直接领导就是在上级业务组织单元中担任负责角色的人,
<br>2) 否则他没有业务直接上级。

* @param employee Employee
* @param workGroups WorkGroup[]
* @return BusinessLeader[]
* @throws OrganizationException
*/
BusinessLeader[] getBusinessDirectLeaders(Employee employee,
                  WorkGroup[] workGroups) throws
OrganizationException;
}
